﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace XYAC.Framework.MonitorTireMaterialManual.Converters
{

    using System;
    using System.ComponentModel;
    using System.Reflection;
    using System.Text;

    public static class PropertyNameConverter
    {
        /// <summary>
        /// 将私有字段名转换为帕斯卡命名的公共属性名
        /// </summary>
        /// <param name="fieldName">私有字段名（支持_前缀或m_前缀）</param>
        /// <returns>帕斯卡命名的属性名</returns>
        public static string ConvertToPascalProperty(string fieldName)
        {
            if (string.IsNullOrWhiteSpace(fieldName))
                return fieldName;

            // 处理常见的命名前缀（_或m_）
            var cleanName = fieldName.TrimStart('_');
            if (cleanName.StartsWith("m_"))
                cleanName = cleanName.Substring(2);

            if (cleanName.Length == 0)
                return string.Empty;

            // 首字母大写转换
            var sb = new StringBuilder(cleanName.Length);
            sb.Append(char.ToUpper(cleanName[0]));
            if (cleanName.Length > 1)
                sb.Append(cleanName.Substring(1));

            return sb.ToString();
        }
        /// <summary>
        /// 使用公共属性的方式来获取描述信息。
        /// 采用此方法时，被反射的类的属性是正常编写的（而非使用诸如ObservableProperty 生成的属性)。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string GetFormattedPropertyComments<T>(T value)
        {
            // 获取 T 类型的所有属性
            var type = typeof(T);
            var properties = type.GetProperties();

            // 用于存储格式化的文本
            StringBuilder formattedText = new StringBuilder();

            foreach (var property in properties)
            {
                // 获取属性上的所有注释（Description）
                var summaryAttribute = property.GetCustomAttributes(typeof(DescriptionAttribute), true)
                                                .Cast<DescriptionAttribute>()
                                                .FirstOrDefault();

                // 获取属性的值
                var propertyValue = property.GetValue(value);

                if (summaryAttribute != null)
                {
                    if (propertyValue != null && float.TryParse(propertyValue.ToString(), out float fValue))
                    {
                        // 如果存在注释（Description），将其格式化到文本中，显示注释和值
                        formattedText.AppendLine($"{summaryAttribute.Description}: {fValue.ToString("F2")}");
                    }
                    else
                    {
                        // 如果存在注释（Description），将其格式化到文本中，显示注释和值
                        formattedText.AppendLine($"{summaryAttribute.Description}: {propertyValue}");
                    }
                }
            }

            // 返回格式化后的文本
            return formattedText.ToString();
        }

        /// <summary>
        /// 使用私有字段的方式来描述信息。
        /// 采用此方法时，被反射的类的属性通常使用动态代码生成(例如ObservableProperty 生成了属性)。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="value"></param>
        /// <returns></returns>
        public static string GetFormattedPropertyComments_v2<T>(T value)
        {
            // 用于存储格式化的文本
            StringBuilder formattedText = new StringBuilder();

            // 获取 T 类型的所有属性
            var type = typeof(T);
            foreach (FieldInfo field in type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)) // 获取私有字段
            {
                // 检查字段是否有Description属性
                var descriptionAttribute = field.GetCustomAttribute<DescriptionAttribute>();
                if (descriptionAttribute != null)
                {
                    // 获取属性的值
                    //var propertyValue = field.GetValue(type.GetConstructors()[0].Invoke(null));

                    // 获取属性的值
                    var property = type.GetProperty(PropertyNameConverter.ConvertToPascalProperty(field.Name));
                    var propertyValue = property.GetValue(value);

                    if (propertyValue != null && float.TryParse(propertyValue.ToString(), out float fValue))
                    {
                        // 如果存在注释（Description），将其格式化到文本中，显示注释和值
                        formattedText.AppendLine($"{descriptionAttribute.Description}: {fValue.ToString("F2")}");
                    }
                    else
                    {
                        // 如果存在注释（Description），将其格式化到文本中，显示注释和值
                        formattedText.AppendLine($"{descriptionAttribute.Description}: {propertyValue}");
                    }
                    //Console.WriteLine($"Field Name: {field.Name}");
                    //Console.WriteLine($"Description: {descriptionAttribute.Description}");
                    //Console.WriteLine($"Field Value: {field.GetValue(type.GetConstructors()[0].Invoke(null))}"); // 获取字段值，这里假设是默认构造函数初始化
                }
            }
            // 返回格式化后的文本
            return formattedText.ToString();
        }

        public static FieldInfo[] GetFormattedPropertyComments_v3<T>(T value)
        {
            // 获取 T 类型的所有属性
            var type = typeof(T);
            return type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance); // 获取私有字段
        }
        public static PropertyInfo[] GetFormattedPropertyComments_v4<T>(T value)
        {
            // 获取 T 类型的所有属性
            var type = typeof(T);
            return type.GetProperties();
        }
    }
}